﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using Sinacor.UI.Bovespa.Ordens;
using Sinacor.Infra.UI.Common;
using Sinacor.Infra.Common.Validation;
using Sinacor.UI.Bovespa.Clientes.Model;
using Sinacor.UI.Bovespa.Ordens.Model;
using Sinacor.Infra.Common.Exceptions;



namespace Sinacor.UI.Bovespa.Ordens.Presenter
{
    /// <summary>
    ///  Interface para implementação da view ResumoFinanceiro.
    /// </summary>
    /// <user>asoares</user>

    public class DigitacaoDistribuicaoOrdem : BasePresenter<IDigitacaoDistribuicaoOrdem>
    {
        #region Constructor
        public DigitacaoDistribuicaoOrdem(IDigitacaoDistribuicaoOrdem view)
            : base(view)
        {
            this._view = view;
            this.ListOrdem = new ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Ordem>();
            this.OrdemModel = new Model.Ordem();
            this.ListNegocio = new ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Negocio>();
            this.ListModelClienteCVM = new ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Cliente>();
            this.ListDigitacao = new ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.BaseDigitacao>();
            this.QuantidadeCasada = 0;
            this.ZeraValores();
           
        }
        #endregion

        #region Propriedades

        #region Private
        public string ApelidoAtual = null; 
        private IDigitacaoDistribuicaoOrdem _view;
        private ModelCollection<Model.Ordem> _listOrdem;
        private ModelCollection<Model.Negocio> _listNegocio;
        private ModelCollection<Model.BaseDigitacao> _listDigitacao;
        private Model.PosicaoCustodia _modelPosicaoCustodia;
        private Model.CarteiraMercado _carteiraMercado;
        private bool _derivativo;
        private bool _naoDerivativo;
        private bool _blPercentual;
        private bool _blDireto;
        private bool _blPrecoMedio;
        private PesquisaCliente _pesquisaClienteModel;
        private Model.Cliente _modelClienteOrdem;
        private ModelCollection<Model.Cliente> _listModelClienteCVM;
        private Model.Cliente _modelClienteDigitacao;
        private Model.AgenteCustodia _modelAgenteCustodia;
        private Model.UsuarioInstitucional _modelUsuarioInstitucional;
        private bool _verificaDigitacaoDigitoCliente;
        private DateTime _dataPregao;
        private bool _habilitarDigitacaoCliente = false;
        private bool _bErro = false;
        private const int ERRO_CLIENTE_INEXISTENTE_OU_USUARAIOSEMACESSO = 109034;
        private const int ERRO_PESQUISA_SEM_RESULTADO = 105000;
        private  ValidationResult _retorno = null;
        private bool _contemNovoMercado;

        public bool ContemNovoMercado
        {
            get { return this._contemNovoMercado; }
            set { this._contemNovoMercado = value; }
        }

        public ValidationResult retorno
        {
            get { return _retorno;  }
            set { _retorno = value; }
        }
        private bool _ativarConsultaCliente = false;

        private Model.DistribuicaoOrdensLoteControles _distribuicaoControles = new DistribuicaoOrdensLoteControles();
        public Model.DistribuicaoOrdensLoteControles DistribuicaoControles
        {
            get { return this._distribuicaoControles; }
            set { this._distribuicaoControles = value; }
        }
        

        public bool bErro
        {
            get { return _bErro; }
            set { _bErro = value; }
        } 
        private Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdemDistribuicao tipoOrdemDistribuicao;

        public Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdemDistribuicao TipoOrdemDistribuicao
        {
            get { return tipoOrdemDistribuicao; }
            set { tipoOrdemDistribuicao = value; }
        } 

        public ModelCollection<Model.Ordem> pLoteOrdem
        {
            get;
            set; 

        }

        public bool HabilitarDigitacaoDigitoCliente
        {
            get { return _habilitarDigitacaoCliente; }
           
        }
        public void HabilitarConsultaCliente (bool habilitado) 
        
        {
            this.DistribuicaoControles.AtivarConsultaCliente = habilitado;
        }
        private bool verificarObrigatoriedade()
        {
            Communication.Parametro parametro = new Sinacor.UI.Bovespa.Ordens.Communication.Parametro(this.Session);

            return (parametro.RecuperarIndicadorDigitoCliente().IndicadorDigitoCliente == "S"); 
        }

       



        #endregion

        #region Public
        public bool NaoDerivativo
        {
            get { return _naoDerivativo; }
            set { _naoDerivativo = value; }
        }
        public bool Derivativo
        {
            get { return _derivativo; }
            set { _derivativo = value; }
        }
        public Model.Ordem OrdemModel
        {
            get;
            private set;
        }
        public bool blDiscricionarios
        {
            get;
            private set;
        }
        public ModelCollection<Model.Ordem> ListOrdem
        {
            get { return _listOrdem; }
            set
            {
                _listOrdem = value;
                if (_listOrdem != null)
                {
                    // Habilitando controle de estado, procure habilitar o 
                    // controle de estado no set da property
                    this.ListOrdem.EnableStateControl = true;
                }
            }
        }
        public ModelCollection<Model.Negocio> ListNegocio
        {
            get { return _listNegocio; }
            set
            {
                _listNegocio = value;
                if (_listNegocio != null)
                {
                    // Habilitando controle de estado, procure habilitar o 
                    // controle de estado no set da property
                    this.ListNegocio.EnableStateControl = true;
                }
            }
        }
        public ModelCollection<Model.BaseDigitacao> ListDigitacao
        {
            get { return _listDigitacao; }
            set
            {
                _listDigitacao = value;
                if (_listDigitacao != null)
                {
                    // Habilitando controle de estado, procure habilitar o 
                    // controle de estado no set da property
                    this.ListDigitacao.EnableStateControl = true;
                }
            }
        }
        public Model.CarteiraMercado CarteiraMercado
        {
            get { return _carteiraMercado; }
            set
            {
                this._carteiraMercado = value;

            }


        }
        public decimal? PrecoMedio
        {
            get;
            set;
        }
        public bool blConsultaCVM
        {
            get;
            set;

        }
        public bool blPercentual
        {
            get
            {
                return _blPercentual;
            }
            set
            {
                if (value == true)
                {
                    _blPercentual = true;
                    _blDireto = false;
                    _blPrecoMedio = false;
                }
            }
        }
        public bool blDireto
        {
            get
            {
                return _blDireto;
            }
            set
            {
                if (value == true)
                {
                    _blPercentual = false;
                    _blDireto = true;
                    _blPrecoMedio = false;
                }
            }
        }
        public bool blInserir
        {
            get;
            set;
        }
        public bool blPrecoMedio
        {
            get
            {
                return _blPrecoMedio;
            }
            set
            {
                if (value == true)
                {
                    _blPercentual = false;
                    _blDireto = false;
                    _blPrecoMedio = true;
                }
            }
        }
        public decimal? PercentualCasado
        {
            get;
            set;

        }
        public decimal? PercentualDigitado
        {
            get;
            set;

        }
        public decimal? PrecoMedioLote
        {
            get;
            set;

        }
        public decimal? QuantidadeCasada
        {
            get;
            set;

        }

        public decimal? QuantidadeCasadaPercentual
        {
            get;
            set;

        }
        public decimal? QuantidadeCasadaAnexoIV
        {
            get;
            set;
        }
        public decimal? QuantidadeCasadaAnexoV
        {
            get;
            set;
        }
        public decimal? QuantidadeDigitada
        {
            get;
            set;
        }
        public decimal? QuantidadeDigitadaAnexoIV
        {
            get;
            set;
        }
        public decimal? QuantidadeDigitadaAnexoV
        {
            get;
            set;

        }
        public decimal? Saldo
        {
            get;
            set;

        }
        public decimal? SaldoAnexoIV
        {
            get;
            set;
        }
        public decimal? SaldoAnexoV
        {
            get;
            set;

        }
        public decimal? SaldoPercentual
        {
            get;
            set;
        }
        public PesquisaCliente PesquisaClienteModel
        {
            get { return _pesquisaClienteModel; }
            set { _pesquisaClienteModel = value; }
        }
        public Model.Cliente ModelClienteOrdem
        {
            get { return _modelClienteOrdem; }
            set { _modelClienteOrdem = value; }
        }
        public ModelCollection<Model.Cliente> ListModelClienteCVM
        {
            get { return _listModelClienteCVM; }
            set
            {
                _listModelClienteCVM = value;
                if (_listModelClienteCVM != null)
                {
                    // Habilitando controle de estado, procure habilitar o 
                    // controle de estado no set da property
                    this.ListModelClienteCVM.EnableStateControl = true;
                }
            }

        }
        public Model.Cliente ModelClienteDigitacao
        {
            get { return _modelClienteDigitacao; }
            set { _modelClienteDigitacao = value; } 
        }
        public Model.AgenteCustodia ModelAgenteCustodia
        {
            get { return _modelAgenteCustodia; }
            set { _modelAgenteCustodia = value; }
        }
        public Model.UsuarioInstitucional ModelUsuarioInstitucional
        {
            get { return _modelUsuarioInstitucional; }
            set { _modelUsuarioInstitucional = value; }
        }
        public bool VerificaDigitacaoDigitoCliente
        {
            get { return _verificaDigitacaoDigitoCliente; }
            set { _verificaDigitacaoDigitoCliente = value; }
        }
        public Model.ADR ModelClienteADR
        {
            private set;
            get;
        }
        public Model.Parameter.ValidarDigitoVerifClienteInstitucionalRequest ModelValidarDigiVerifClienteInst
        {
            get;
            set;

        }
        public Model.PosicaoCustodia ModelPosicaoCustodia
        {
            get { return _modelPosicaoCustodia; }
            set { _modelPosicaoCustodia = value; }
        
        }
        public DateTime DataPregao
        {
            get { return _dataPregao; }
            set { _dataPregao = value; }
        }
        
        #endregion

        #endregion

        #region Metodos

        #region Public 
            public void CarregarGridOrdem(ModelCollection<Model.Ordem> pOrdem , Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdemDistribuicao ptipoOrdemDistribuicao)
            {

                tipoOrdemDistribuicao = ptipoOrdemDistribuicao; 

                pLoteOrdem = pOrdem;

                if (tipoOrdemDistribuicao == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdemDistribuicao.AdministradoConcorrente ||
                    tipoOrdemDistribuicao == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdemDistribuicao.POP)
                {
                    this.ListOrdem = pOrdem; 
                }

                else
                {
                    this.ListOrdem = CarregarOrdemLote(pLoteOrdem);
                    carregarLoteQuantidade(pLoteOrdem);
                } 
                _view.ApresentarGridOrdem();
               
                _habilitarDigitacaoCliente = verificarObrigatoriedade(); 
            }

            private void carregarLoteQuantidade(ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Ordem> pLoteOrdem)
            {
                Communication.Titulo consultarTitulo = new Sinacor.UI.Bovespa.Ordens.Communication.Titulo(this.Session); 

                foreach ( Model.Ordem pitem  in pLoteOrdem ) 
                {
                    pitem.AtivoQuantidadeMinima = consultarTitulo.ConsultarLoteMinimoNegociacao(TranslateOrdemToTitulo(pitem)); 
                }
            }

            private Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarLoteMinimoNegociacaoRequest TranslateOrdemToTitulo(Sinacor.UI.Bovespa.Ordens.Model.Ordem pitem)
            {
                Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarLoteMinimoNegociacaoRequest lote = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarLoteMinimoNegociacaoRequest();
                lote._DataPregao = DataPregao; 
                lote._Titulo = pitem.Titulo;
                return lote;


            }

            private ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Ordem> CarregarOrdemLote(ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Ordem> pOrdem)
            {
                Ordens.Communication.Ordem consultarOrdemLote = new Sinacor.UI.Bovespa.Ordens.Communication.Ordem(this.Session );

                List<Model.Parameter.ConsultarOrdemDistribuicaoOrdemLote> pconsultarOrdemDistribuicaoLote = new List<Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarOrdemDistribuicaoOrdemLote>(); 


                return consultarOrdemLote.ConsultarOrdemDistribuicaoOrdemLote(TranslateConsultarOrdemParameterConsultarOrdemLote(pOrdem));

            }

            private List<Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarOrdemDistribuicaoOrdemLote> TranslateConsultarOrdemParameterConsultarOrdemLote(ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Ordem> pOrdem)
            {

                List<Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarOrdemDistribuicaoOrdemLote> consulta = new List<Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarOrdemDistribuicaoOrdemLote>();

                foreach (Model.Ordem pitem in pOrdem)
                {
                    consulta.Add(TranslateOrdemParaLote(pitem)); 
                }

                return consulta;  
            }

            private Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarOrdemDistribuicaoOrdemLote TranslateOrdemParaLote(Sinacor.UI.Bovespa.Ordens.Model.Ordem pitem)
            {
                Model.Parameter.ConsultarOrdemDistribuicaoOrdemLote pLote = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarOrdemDistribuicaoOrdemLote();

                pLote.NumeroConjunto = (int) pitem.NumeroConjunto;

                return pLote;

            }

            public void CarregarGridNegocio()
            {

                    try
                    {
                        Communication.Negocio objNegocio = new Communication.Negocio(this.Session);

                        if (tipoOrdemDistribuicao == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdemDistribuicao.AdministradoConcorrente ||
                            tipoOrdemDistribuicao == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdemDistribuicao.POP)
                        {
                            Model.Parameter.ConsultarNegocioOrdemDigitacao pNegocioOrdem = new Model.Parameter.ConsultarNegocioOrdemDigitacao();
                            pNegocioOrdem.DataOrdem = ListOrdem[0].DataOrdem;
                            pNegocioOrdem.NumeroOrdemSubSequencia = ListOrdem[0].NumeroOrdemSubSequencia;
                            pNegocioOrdem.DataPregao = DataPregao;
                            pNegocioOrdem.NumeroOrdem = ListOrdem[0].NumeroOrdem;
                            this._listNegocio = objNegocio.ConsultarNegocioOrdemDigitacao(pNegocioOrdem);

                        }
                        else
                        {


                            this._listNegocio = objNegocio.ConsultarNegocioListaLoteDigitacao(TranslateTraduzirNegocioListaRequest(pLoteOrdem));

                        }
                    }
                    catch (Exception ex)
                    {

                        base.HandleException(ex);

                    }
               


            }

            private List<Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarNegocioLoteDigitacao> TranslateTraduzirNegocioListaRequest(ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Ordem> pOrigem)
            {
                List<Model.Parameter.ConsultarNegocioLoteDigitacao> lista = new List<Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarNegocioLoteDigitacao>();

                for (int i = 0; i < pOrigem.Count; i++ )
                {
                    lista.Add (TranslateLoteItemNegocioRequest (pOrigem [i]));

                }

                return lista; 

            }

            private Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarNegocioLoteDigitacao TranslateLoteItemNegocioRequest(Sinacor.UI.Bovespa.Ordens.Model.Ordem ordem)
            {
                Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarNegocioLoteDigitacao to = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarNegocioLoteDigitacao();

                to.DataPregao = this.DataPregao;

                to.NumeroConjunto =  (int) ordem.NumeroConjunto;
                return to; 
            }

            public void CarregarGridDigitacao()
            {
                try
                {


                    if (tipoOrdemDistribuicao == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdemDistribuicao.POP ||
                     tipoOrdemDistribuicao == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdemDistribuicao.AdministradoConcorrente)
                    {

                        //if (tipoOrdemDistribuicao == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdemDistribuicao.AdministradoConcorrente ||
                        {
                            //{
                            Model.Parameter.ConsultarOrdemDigitacao pConsultarOrdemDigitacao = new Model.Parameter.ConsultarOrdemDigitacao();
                            Communication.OrdemDigitacao objOrdemDigitacao = new Communication.OrdemDigitacao(this.Session);
                            pConsultarOrdemDigitacao.DataMovimento = DataPregao;

                            pConsultarOrdemDigitacao.NumeroOrdem = (Int64)pLoteOrdem[0].NumeroOrdem;

                            pConsultarOrdemDigitacao.NumeroOrdemSubSequencia = pLoteOrdem[0].NumeroOrdemSubSequencia;


                            this.ListDigitacao = objOrdemDigitacao.ConsultarOrdemDigitacao(pConsultarOrdemDigitacao); ;
                        }
                    }

                    else
                    {

                        if (this.pLoteOrdem.Count == 1)
                        {
                            Model.Parameter.ConsultarOrdemDistribuicaoOrdemLote pConsultarOrdemDigitacaoLote = new Model.Parameter.ConsultarOrdemDistribuicaoOrdemLote ();

                            Communication.OrdemDigitacao objOrdemDigitacao = new Communication.OrdemDigitacao(this.Session);
                            pConsultarOrdemDigitacaoLote.DataMovimento = DataPregao;

                            pConsultarOrdemDigitacaoLote.NumeroConjunto = (int) pLoteOrdem[0].NumeroConjunto;
                           
                            
                            this.ListDigitacao = objOrdemDigitacao.ConsultarOrdemDigitacaoLote(pConsultarOrdemDigitacaoLote); ;

 
                        }

 
                    }
                }
                catch (Exception ex)
                {

                    base.HandleException(ex);

                }
            }

            public void CarregarDigitacao()
            {
                this.CarregarGridDigitacao();
                _view.ApresentarDistribuicao();
                if (this.ListDigitacao.Count == 0)
                {
                    _view.ConfiguraDigitacaoVazia();

                }
                else
                {
                    _view.ConfiguraDigitacaoComItens();

                }
            }

            public void CarregarCabecalho()
            {
                if (ListOrdem[0] != null)
                    this.OrdemModel = ListOrdem[0];
            }

              public void CalculaPrecoMedio()
            {
                decimal? Qtd;
                decimal? Valor;
                Qtd = 0;
                Valor = 0;

                try
                {
                    for (int i = 0; i < ListNegocio.Count; i++)
                    {
                        Qtd = ListNegocio[i].Quantidade + Qtd;
                        Valor = (ListNegocio[i].Preco * ListNegocio[i].Quantidade) + Valor;
                    }
                    
                    this.PrecoMedio = (Valor / Qtd);
                    if (this.PrecoMedio > 0)
                        this.PrecoMedio = decimal.Round((decimal)this.PrecoMedio, 6);
                }
                catch
                {
                    this.PrecoMedio = 0;

                }

                _view.ApresentarPrecoMedio();
                
            }

            public void VerificaTipoMercado()
            {
                int Count = ListOrdem.Count;
                _derivativo = false;
                _naoDerivativo = false; 
                for (int i = 0; i < Count; i++)
                {

                    if ((this.ListOrdem[i].TipoMercado == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoMercado.OpcaoVenda) ||
                        (this.ListOrdem[i].TipoMercado == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoMercado.OpcaoCompra) ||
                        (this.ListOrdem[i].TipoMercado == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoMercado.Termo) ||
                        (this.ListOrdem[i].TipoMercado == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoMercado.Futuro))
                    {
                        _derivativo = true;
                    }
                    else
                    {
                        _naoDerivativo = true;                        
                    }
                }

                int count = this.ListOrdem.Count(item => item.TipoMercado == (Model.Enum.TipoMercado.IntegralizacaoResgateCotas) || item.TipoMercado == (Model.Enum.TipoMercado.CotasETF));

                this.ContemNovoMercado = (count > 0);
            }

            public void VerificaMetodoDistribuicao()
            {
                int Count = ListOrdem.Count;


                if (ListDigitacao[0].PrecoInformado != null && ListDigitacao[0].PrecoInformado != 0 && ListDigitacao[0].QuantidadeDestinadaCliente != null && ListDigitacao[0].QuantidadeDestinadaCliente != 0)
                    blDireto = true;
                else if (ListDigitacao[0].PercentualDistribuido != null && ListDigitacao[0].PercentualDistribuido != 0)
                    blPercentual = true;
                else
                    blPrecoMedio = true;


                _view.AlterarStatusControle();

            }

            public void VerificaPermissaoUsuario()
            {
                try
                {
                  //  bool blAcesso = Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso.VerificarAcessoFuncao("ADST"); 

                 //Bovespa.

                    bool blAcesso;
                    Communication.Acesso objAcesso = new Communication.Acesso(this.Session);
                    Model.Parameter.VerificarAcessoFuncaoRequest mVerificarAcessoFuncaoRequest = new Model.Parameter.VerificarAcessoFuncaoRequest();
                    mVerificarAcessoFuncaoRequest.Funcao = "ADST";
                    blAcesso = objAcesso.VerificarAcesso(mVerificarAcessoFuncaoRequest);
                    if (blAcesso == false)
                        _view.DesabilitarColReducaoAcrescimo();
                    else
                        _view.HabilitarColReducaoAcrescimo();
                }
                catch (Exception ex)
                {

                    base.HandleException(ex);

                }


            }

            public void VerificaClienteBroker()
            {
                if (this.ModelClienteOrdem.isClienteBroker == true)
                    _view.DesabilitaCheckBoxContaInvestimento();
            }

            public void CarregarClienteOrdem()
            {
                try
                {

                    Model.Parameter.ConsultarClienteRequest pConsultarCliente = new Model.Parameter.ConsultarClienteRequest();
                    if (this.tipoOrdemDistribuicao != Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdemDistribuicao.POP) 
                        pConsultarCliente.Apelido = pLoteOrdem[0].ApelidoCliente;
                    else
                        pConsultarCliente.Apelido = pLoteOrdem[0].ApelidoBroker;

                    Communication.Cliente objCliente = new Communication.Cliente(this.Session);
                    this.ModelClienteOrdem = objCliente.ConsultarCliente(pConsultarCliente)[0];
                }
                catch (Exception ex)
                {

                    base.HandleException(ex);

                }

            }

            public void CarregarPopupCliente()
            {
                try
                {

                    Model.Parameter.ConsultarClienteRequest pConsultarCliente = new Model.Parameter.ConsultarClienteRequest();
                    pConsultarCliente.Codigo = pLoteOrdem[0].CodigoCliente;
                    Communication.Cliente objCliente = new Communication.Cliente(this.Session);
                    this.ModelClienteOrdem = objCliente.ConsultarCliente(pConsultarCliente)[0];
                }
                catch (Exception ex)
                {

                    base.HandleException(ex);

                }
                
            }

            public void AtualizaValores()
            {
                
                this.ZeraValores();
                AtualizarQtdCasada();
                AtualizarQuantidadeEspefificar();
            //if (ListDigitacao.Count > 0)
                {
                    AtualizarQuantidadeInformada();
                    AtualizarPercentual();
                    AtualizarSaldo();
                  
                }

                _view.ApresentarValores();
            }

            public bool VerificarValorDigitado(decimal? Valor)
            {

                for (int i = 0; i < this.ListNegocio.Count; i++)
                {
                    if (ListNegocio[i].Preco == Valor)
                        return true;
                }

                return false;

            }

            public bool VerificaMultiploQtd(Decimal? Qtd, string papel)
            {
                try
                {
                    bool valido = true;

                    for (int i = 0; i < pLoteOrdem.Count; i++)
                    {
                        if (papel == pLoteOrdem[i].Titulo)
                        {
                            int multiploMinimo = this.pLoteOrdem[i].AtivoQuantidadeMinima; //objTitulo.ConsultarLoteMinimoNegociacao(mConsultarLoteMinimo);


                                if (multiploMinimo != 0)
                                    if ((Qtd % multiploMinimo > 0))
                                    {
                                        valido = false;
                                        break;
                                    }
                        }
                    }

                    return valido;
                }
                catch (Exception ex)
                {

                    base.HandleException(ex);
                    return false;

                }
            }


            public bool VerificaMultiploQtd(Decimal? Qtd)
            {
                try
                {
                    bool valido = true;

                    for (int i = 0; i < pLoteOrdem.Count; i++)
                    {
                            int multiploMinimo = this.pLoteOrdem[i].AtivoQuantidadeMinima; //objTitulo.ConsultarLoteMinimoNegociacao(mConsultarLoteMinimo);


                            if (multiploMinimo != 0)
                                if ((Qtd % multiploMinimo > 0))
                                {
                                    valido = false;
                                    break;
                                }
                    }

                    return valido;
                }
                catch (Exception ex)
                {

                    base.HandleException(ex);
                    return false;

                }
            }
            public bool VerificarPorcentagemMinMultiplo( decimal Percentual )
            {
                try
                {


                    var ativo = from Bovespa.Ordens.Model.Ordem lista in ListOrdem
                                group lista by new { lista.Titulo, lista.TipoMercado } into titulo
                                select new {  retorno = titulo.Sum(p => p.QuantidadeCasada), papel = titulo.Key  }; 


                    foreach  (var m in ativo )
                    {

                        if (!VerificaMultiploQtd(((decimal?)decimal.Round(Percentual * (decimal)m.retorno, 0) / 100)
                            ,m.papel.Titulo))
                            return false;
                    }
                    return true;

                }
                catch (Exception ex)
                {

                    base.HandleException(ex);
                    return false;

                }
            
            
            }

            private bool ValidarMultiploQtd(decimal? percentualQtde, string titulo )
            {
                int multiploMinimo = 0;

                foreach (Model.Ordem  item in pLoteOrdem)
                {
                    if (item.Titulo == titulo) 
                    {
                        multiploMinimo = item.AtivoQuantidadeMinima; 
                        break;
                    }
                }
                if (multiploMinimo == 0)
                    return true; 

                if (percentualQtde % multiploMinimo > 0)
                
                    return false;

                else

                    return true;

               
            }
            //public bool VerificarPorcentagemMinMultiplo( decimal Percentual )
            //{
            //    try 
            //    {

            //        if (pLoteOrdem.Count == 1)
            //        {
            //            for (int i = 0; i < ListNegocio.Count; i++)
            //            {

            //                if (VerificaMultiploQtd((decimal?)decimal.Round(Percentual * (decimal)ListNegocio[i].Quantidade, 0)) == false)
            //                    return false;
            //            }

            //        }
            //        else
            //        {


            //            for (int i = 0; i < ListNegocio.Count; i++)
            //            {

            //                if (ValidarMultiploQtd((decimal?)decimal.Round(Percentual * (decimal)ListNegocio[i].Quantidade, 0),ListNegocio[i].Titulo.Codigo ) == false)
            //                    return false;
                          
            //            }

            //        }
            //        return true;
                
            //    }
            //    catch (Exception ex)
            //    {

            //        base.HandleException(ex);
            //        return false;

            //    }
             
            //}

            public bool Excluir()
            {
                try
                {

                    bErro = false; 

                    
                    ValidarSaldoMensagem(this.View.VerificaTipoDistribuicao());

                    if (bErro ) 
                        return false; 
                   
                    if (tipoOrdemDistribuicao == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdemDistribuicao.AdministradoConcorrente ||
                        tipoOrdemDistribuicao == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdemDistribuicao.POP)
                    {
                        bool excluido = true; 

                                foreach (Model.Ordem pitem in pLoteOrdem)
                                {

                                    Communication.OrdemDigitacao objOrdemDigitacao = new Communication.OrdemDigitacao(this.Session);
                                    ModelCollection<Model.Parameter.ExcluirOrdemDigitacao> modelExcluirOrdemDigitacao = new ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Parameter.ExcluirOrdemDigitacao>();
                                    foreach (Model.BaseDigitacao modOrdemDigitacao in this.ListDigitacao)
                                    {
                                        // if (modOrdemDigitacao.State == State.Deleted || modOrdemDigitacao.State == State.Updated)
                                        
                                            if (modOrdemDigitacao.State == State.Deleted || modOrdemDigitacao.State == State.Updated)
                                            {
                                                Model.Parameter.ExcluirOrdemDigitacao objExcluirOrdem = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ExcluirOrdemDigitacao();
                                                objExcluirOrdem.DataMovimento = DataPregao;
                                                objExcluirOrdem.NumeroOrdem = pitem.NumeroOrdem;
                                                objExcluirOrdem.NumeroSequenciaDistribuicao = (int?)modOrdemDigitacao.NumeroSequenciaDigitacao;
                                                objExcluirOrdem.NumeroSubSequenciaDistribuicao = pitem.NumeroOrdemSubSequencia;
                                                objExcluirOrdem.TipoDistribuicao = this._view.VerificaTipoDistribuicao();
                                                objExcluirOrdem.TipoOrdemDistribuicao = this.tipoOrdemDistribuicao ;
                                                objExcluirOrdem.DataOrdem = DataPregao;

                                                modelExcluirOrdemDigitacao.Add(objExcluirOrdem);
                                            }
                                        
                                    }

                                        if (modelExcluirOrdemDigitacao.Count > 0)
                                        {
                                            if (!objOrdemDigitacao.Excluir(modelExcluirOrdemDigitacao))
                                                excluido = false;
                                        }
                                
                        }

                        return excluido;  
                    }
                    else
                    {
                        bool excluido = true;
                        foreach (Model.Ordem pitem in pLoteOrdem)
                        {

                                Communication.LoteDigitacao objLoteDigitacao = new Communication.LoteDigitacao(this.Session);
                                ModelCollection<Model.Parameter.ExcluirLoteDigitacao> modelExcluirLoteDigitacao = new ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Parameter.ExcluirLoteDigitacao>();
                                foreach (Model.BaseDigitacao objOrdemDigitacao in this.ListDigitacao.GetChanged ())
                                {
                                    if (objOrdemDigitacao.State == State.Deleted || objOrdemDigitacao.State == State.Updated)
                                    {

                                        Model.Parameter.ExcluirLoteDigitacao objExcluirLoteDigitacao = new Model.Parameter.ExcluirLoteDigitacao();
                                        objExcluirLoteDigitacao.DataOrdem = DataPregao;
                                        objExcluirLoteDigitacao.NumeroConjunto = pitem.NumeroConjunto;
                                        objExcluirLoteDigitacao.NumeroOrdemSubSequencia = (int)pitem.NumeroOrdemSubSequencia;
                                        objExcluirLoteDigitacao.NumeroSequenciaDistribuicao = (int)objOrdemDigitacao.NumeroSequenciaDigitacao;
                                        objExcluirLoteDigitacao.TipoDistribuicao = this._view.VerificaTipoDistribuicao();
                                        modelExcluirLoteDigitacao.Add(objExcluirLoteDigitacao);
                                    }
                                    
                                }
                                if (modelExcluirLoteDigitacao.Count > 0)
                                {
                                    if (!objLoteDigitacao.ExcluirLoteDigitacao(modelExcluirLoteDigitacao))
                                    {
                                        excluido = false;
                                    }
                                }

                          
                        }
                        return excluido; 
                    }
                }
                catch (Exception ex)
                {

                    base.HandleException(ex);
                    _bErro = true; 
                    return false;

                }
            }

            public bool SalvarGridDigitacao()
            {
                try
                {


                    if (bErro == true)
                        return false; 

                 if (!bErro)
                 {

                     if (tipoOrdemDistribuicao == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdemDistribuicao.AdministradoConcorrente ||
                         tipoOrdemDistribuicao == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdemDistribuicao.POP)

                         return salvarDigitacaoOrdem();

                     else
                         return salvarDigitacaoLote();
                 }
                 return bErro; 
                   
                }
                catch (Exception ex)
                {
                    AtualizarSaldo(); 
                    base.HandleException(ex);
                    _bErro = true ; 
                    return false;

                }

            }

            private bool salvarDigitacaoLote()
            {
                Communication.LoteDigitacao objLoteDigitacao = new Sinacor.UI.Bovespa.Ordens.Communication.LoteDigitacao(this.Session);
                ModelCollection<Model.LoteDigitacao> ModelLoteDigitacao = new ModelCollection<Model.LoteDigitacao>();

 

                foreach (Model.Ordem pitem in pLoteOrdem)
                {

                    if (pLoteOrdem.Count > 1)
                    {

                        Int32 carteira = (Int32) retornaCarteiraValida(pitem, 0);

                        foreach (Model.BaseDigitacao ItemInclusao in _listDigitacao.GetChanged())
                        {
                            //if (ItemInclusao.CodigoCarteira == null || )
                            ItemInclusao.CodigoCarteira = carteira ;
                            Model.LoteDigitacao IncluirLoteDigitacao = new Sinacor.UI.Bovespa.Ordens.Model.LoteDigitacao();
                            IncluirLoteDigitacao.ApelidoCliente = ItemInclusao.ApelidoCliente;

                            carregarInstitucional(pitem, ItemInclusao.ApelidoCliente);
                            if (this.ModelAgenteCustodia.DigitoClienteCustodiante != null)
                            {
                                IncluirLoteDigitacao.TipoLiquidacao = Ordens.Model.Enum.TipoLiquidacaoDistribuicao.Custodiante ;
                                IncluirLoteDigitacao.CodigoAgenteCustodia = this.ModelAgenteCustodia.CodigoCustodiante.ToString();
                                IncluirLoteDigitacao.CodigoClienteCustodia = this.ModelAgenteCustodia.CodigoClienteCustodiante;
                                IncluirLoteDigitacao.DigitoClienteCustodiaDigitacao = this.ModelAgenteCustodia.DigitoClienteCustodiante;
                            }

                            else

                            {
                                if (this.ModelUsuarioInstitucional.CodigoUsuarioInstitucional == null) 
                                    IncluirLoteDigitacao.TipoLiquidacao =  Ordens.Model.Enum.TipoLiquidacaoDistribuicao.Normal;
                                else
                                    IncluirLoteDigitacao.TipoLiquidacao = Ordens.Model.Enum.TipoLiquidacaoDistribuicao.Custodiante;

                                IncluirLoteDigitacao.CodigoAgenteCustodia = this.ModelUsuarioInstitucional.CodigoUsuarioInstitucional.ToString();
                                IncluirLoteDigitacao.CodigoClienteCustodia = this.ModelUsuarioInstitucional.CodigoClienteInstitucional;
                                IncluirLoteDigitacao.DigitoClienteCustodiaDigitacao = this.ModelUsuarioInstitucional.DigitoClienteInstitucional;
                            }

                            IncluirLoteDigitacao.CodigoCarteira = ItemInclusao.CodigoCarteira;
                            IncluirLoteDigitacao.CodigoCliente = ItemInclusao.CodigoCliente;
                            
                            IncluirLoteDigitacao.CodigoClienteLoteOrdem = ItemInclusao.CodigoClienteLoteOrdem;
                            IncluirLoteDigitacao.DataMovimento = DataPregao;
                            
                            IncluirLoteDigitacao.DigitoVerificadorCliente = ItemInclusao.DigitoVerificadorCliente;
                            IncluirLoteDigitacao.IndicadorNaoLiquidacao = ItemInclusao.IndicadorNaoLiquidacao;
                            IncluirLoteDigitacao.IndicadorSistemaExterno = ItemInclusao.IndicadorSistemaExterno;
                            IncluirLoteDigitacao.NumeroConjunto = pitem.NumeroConjunto;  //ListOrdem[0].NumeroConjunto;
                            IncluirLoteDigitacao.NumeroSequenciaDigitacao = pitem.NumeroOrdemSubSequencia;// ListOrdem[0].NumeroOrdemSubSequencia;
                            IncluirLoteDigitacao.PercentualAcrescimo = ItemInclusao.PercentualAcrescimo;
                            IncluirLoteDigitacao.PercentualDistribuido = ItemInclusao.PercentualDistribuido;
                            IncluirLoteDigitacao.PrecoInformado = ItemInclusao.PrecoInformado;
                            IncluirLoteDigitacao.QuantidadeDestinadaCliente = ItemInclusao.QuantidadeDestinadaCliente;
                            IncluirLoteDigitacao.SituacaoCliente = ItemInclusao.SituacaoCliente;
                            IncluirLoteDigitacao.TipoDistribuicao = _view.VerificaTipoDistribuicao();
                           
                            IncluirLoteDigitacao.UtilizaContaInvestimento = ItemInclusao.UtilizaContaInvestimento;
                            IncluirLoteDigitacao.ValorDolar = ItemInclusao.ValorDolar;
                            IncluirLoteDigitacao.IndicadorNaoLiquidacao = ItemInclusao.IndicadorNaoLiquidacao;
                            ModelLoteDigitacao.Add(IncluirLoteDigitacao);
                        }

                    }
                    else
                    {
                        foreach (Model.BaseDigitacao ItemInclusao in _listDigitacao.GetChanged())
                        {

                            if (ItemInclusao.State != State.Deleted && ItemInclusao.State != State.Unchanged)
                            {
                                if (ItemInclusao.CodigoCarteira == null)
                                    ItemInclusao.CodigoCarteira = retornaCarteiraValida(pitem, ItemInclusao.CodigoCarteira);
                                Model.LoteDigitacao IncluirLoteDigitacao = new Sinacor.UI.Bovespa.Ordens.Model.LoteDigitacao();
                                IncluirLoteDigitacao.ApelidoCliente = ItemInclusao.ApelidoCliente;
                                IncluirLoteDigitacao.CodigoAgenteCustodia = ItemInclusao.CodigoAgenteCustodia;
                                IncluirLoteDigitacao.CodigoCarteira = ItemInclusao.CodigoCarteira;
                                IncluirLoteDigitacao.CodigoCliente = ItemInclusao.CodigoCliente;
                                IncluirLoteDigitacao.CodigoClienteCustodia = ItemInclusao.CodigoClienteCustodia;
                                IncluirLoteDigitacao.CodigoClienteLoteOrdem = ItemInclusao.CodigoClienteLoteOrdem;
                                IncluirLoteDigitacao.DataMovimento = DataPregao;
                                IncluirLoteDigitacao.DigitoClienteCustodiaDigitacao = ItemInclusao.DigitoClienteCustodiaDigitacao;
                                IncluirLoteDigitacao.DigitoVerificadorCliente = ItemInclusao.DigitoVerificadorCliente;
                                IncluirLoteDigitacao.IndicadorNaoLiquidacao = ItemInclusao.IndicadorNaoLiquidacao;
                                IncluirLoteDigitacao.IndicadorSistemaExterno = ItemInclusao.IndicadorSistemaExterno;
                                IncluirLoteDigitacao.NumeroConjunto = pitem.NumeroConjunto;  //ListOrdem[0].NumeroConjunto;
                                IncluirLoteDigitacao.NumeroSequenciaDigitacao = pitem.NumeroOrdemSubSequencia;// ListOrdem[0].NumeroOrdemSubSequencia;
                                IncluirLoteDigitacao.PercentualAcrescimo = ItemInclusao.PercentualAcrescimo;
                                IncluirLoteDigitacao.PercentualDistribuido = ItemInclusao.PercentualDistribuido;
                                IncluirLoteDigitacao.PrecoInformado = ItemInclusao.PrecoInformado;
                                IncluirLoteDigitacao.QuantidadeDestinadaCliente = ItemInclusao.QuantidadeDestinadaCliente;
                                IncluirLoteDigitacao.SituacaoCliente = ItemInclusao.SituacaoCliente;
                                IncluirLoteDigitacao.TipoDistribuicao = _view.VerificaTipoDistribuicao();
                                IncluirLoteDigitacao.TipoLiquidacao = ItemInclusao.TipoLiquidacao;
                                IncluirLoteDigitacao.UtilizaContaInvestimento = ItemInclusao.UtilizaContaInvestimento;
                                IncluirLoteDigitacao.ValorDolar = ItemInclusao.ValorDolar;
                                IncluirLoteDigitacao.IndicadorNaoLiquidacao = ItemInclusao.IndicadorNaoLiquidacao;
                                ModelLoteDigitacao.Add(IncluirLoteDigitacao);

                            }
                        }
                    }
                }

                if (ModelLoteDigitacao.Count == 0)
                    return true; 
                return objLoteDigitacao.InserirLoteDigitacao(ModelLoteDigitacao);
            }

            private void carregarInstitucional(Model.Ordem pitem, string apelido)
            {
                bool prderivativo=false ; 

                if ((pitem.TipoMercado == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoMercado.OpcaoVenda) ||
                        (pitem.TipoMercado == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoMercado.OpcaoCompra) ||
                        (pitem.TipoMercado == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoMercado.Termo) ||
                        (pitem.TipoMercado == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoMercado.Futuro))
                    {
                        prderivativo = true;
                    }
                    else
                    {
                        prderivativo = false;
                    }

                if (!prderivativo)
                {
                    Communication.Cliente objCliente = new Communication.Cliente(this.Session);
                    Model.Parameter.ConsultarClientePorCodigoRequest pConsultarCliente = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarClientePorCodigoRequest();
                    pConsultarCliente.CodigoCliente = this.ConsultarCodgioClienteApelido(apelido) ;
                    this.ModelAgenteCustodia = objCliente.ConsultarAgenteCustodia(pConsultarCliente);
                    this.ModelUsuarioInstitucional = objCliente.ConsultarUsuarioInstitucional(pConsultarCliente);
                }
                else
                {
                    this.ModelAgenteCustodia = new Sinacor.UI.Bovespa.Ordens.Model.AgenteCustodia();
                    this.ModelAgenteCustodia.CodigoClienteCustodiante = null;
                    this.ModelAgenteCustodia.CodigoCustodiante = null;
                    this.ModelAgenteCustodia.DigitoClienteCustodiante = null;


                    this.ModelUsuarioInstitucional = new Sinacor.UI.Bovespa.Ordens.Model.UsuarioInstitucional();

                    this.ModelUsuarioInstitucional.DigitoClienteInstitucional = null;
                    this.ModelUsuarioInstitucional.CodigoUsuarioInstitucional = null;
                    this.ModelUsuarioInstitucional.CodigoClienteInstitucional = null; 

                }
            }


            private bool salvarDigitacaoOrdem()
            {
                Communication.OrdemDigitacao objOrdemDigitacao = new Communication.OrdemDigitacao(this.Session);
                ModelCollection<Model.OrdemDigitacao> mLoteDigitacao = new ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.OrdemDigitacao>();
                // Ordem (Lote) 


                foreach (Model.Ordem pitem in _listOrdem)
                {


                    foreach (Model.BaseDigitacao ItemInclusao in _listDigitacao.GetChanged())
                    {

                        if (ItemInclusao.State != State.Deleted && ItemInclusao.State != State.Unchanged)
                        {
                            Model.OrdemDigitacao OrdemDigitacao = new Model.OrdemDigitacao();
                            OrdemDigitacao.ApelidoCliente = ItemInclusao.ApelidoCliente;
                            OrdemDigitacao.CodigoAgenteCustodia = ItemInclusao.CodigoAgenteCustodia;
                            OrdemDigitacao.CodigoCarteira = ItemInclusao.CodigoCarteira;
                            OrdemDigitacao.CodigoCliente = ItemInclusao.CodigoCliente;
                            OrdemDigitacao.CodigoClienteCustodia = ItemInclusao.CodigoClienteCustodia;
                            OrdemDigitacao.CodigoClienteLoteOrdem = ItemInclusao.CodigoClienteLoteOrdem;
                            // OrdemDigitacao.CodigoOperadorCVM = _listOrdem[0].IndicadorTipoDistribuicao --> ver com estatoline 
                            OrdemDigitacao.TipoDistribuicao = _view.VerificaTipoDistribuicao(); ;// -> aonde 
                            OrdemDigitacao.DataOrdem = DataPregao;//pitem.DataOrdem ;
                            OrdemDigitacao.DataMovimento = DataPregao;
                            OrdemDigitacao.DigitoClienteCustodiaDigitacao = ItemInclusao.DigitoClienteCustodiaDigitacao;
                            OrdemDigitacao.DigitoVerificadorCliente = ItemInclusao.DigitoVerificadorCliente;
                            OrdemDigitacao.IndicadorNaoLiquidacao = ItemInclusao.IndicadorNaoLiquidacao;
                            OrdemDigitacao.IndicadorSistemaExterno = ItemInclusao.IndicadorSistemaExterno;
                            OrdemDigitacao.NumeroOrdem = pitem.NumeroOrdem;//pitem.NumeroOrdem;
                            OrdemDigitacao.NumeroOrdemSubSequencia = pitem.NumeroOrdemSubSequencia;// pitem.NumeroOrdemSubSequencia;
                            OrdemDigitacao.NumeroSequenciaDigitacao = ItemInclusao.NumeroSequenciaDigitacao;
                            OrdemDigitacao.PercentualAcrescimo = ItemInclusao.PercentualAcrescimo;
                            OrdemDigitacao.PercentualDistribuido = ItemInclusao.PercentualDistribuido;
                            OrdemDigitacao.PrecoInformado = ItemInclusao.PrecoInformado;
                            OrdemDigitacao.QuantidadeDestinadaCliente = ItemInclusao.QuantidadeDestinadaCliente;
                            OrdemDigitacao.SituacaoCliente = ItemInclusao.SituacaoCliente;

                            OrdemDigitacao.TipoLiquidacao = ItemInclusao.TipoLiquidacao;
                            OrdemDigitacao.UtilizaContaInvestimento = ItemInclusao.UtilizaContaInvestimento;
                            OrdemDigitacao.ValorDolar = ItemInclusao.ValorDolar;

                            OrdemDigitacao.TipoOrdemDistribuicao = (Model.Enum.TipoOrdemDistribuicao)tipoOrdemDistribuicao;
                            mLoteDigitacao.Add(OrdemDigitacao);
                        }

                    }
                }
                if (mLoteDigitacao.Count == 0)
                    return true; 
                return objOrdemDigitacao.InserirLoteDigitacao(mLoteDigitacao);
            }



            private int? retornaCarteiraValida(Sinacor.UI.Bovespa.Ordens.Model.Ordem pitem, int? CodigoCarteira)
            {
                if (CodigoCarteira != null && CodigoCarteira > 0)
                    return CodigoCarteira;

                else
                {
                     Model.CarteiraMercado carteiraMerc = new Sinacor.UI.Bovespa.Ordens.Model.CarteiraMercado(); 
                    try
                    {
                       

                        Communication.Carteira objCarteira = new Communication.Carteira(this.Session);
                        Model.Parameter.ConsultarMenorCarteiraRequest ConsultarMenorCarteiraRequest = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarMenorCarteiraRequest();
                        ConsultarMenorCarteiraRequest.CodigoBolsa = pitem.Bolsa;
                        ConsultarMenorCarteiraRequest.CodigoMercado = (Model.Enum.TipoMercado?)pitem.TipoMercado;
                        ConsultarMenorCarteiraRequest.NaturezaOperacao = (Model.Enum.TipoNaturezaOperacao?)pitem.NaturezaOperacao;
                        carteiraMerc = objCarteira.ConsultarMenorCarteira(ConsultarMenorCarteiraRequest);
                    }
                    catch (Exception ex)
                    {

                        base.HandleException(ex);

                    }

                    return carteiraMerc.CodigoCarteira; 
                }

            }


            
            public bool ValidaQtdTotal(Model.BaseDigitacao  baseDigitar, decimal? Qtd, bool novo, int index )
            {
                decimal? QtdDigitacao = 0;
                QtdDigitacao = ObterQuantidadeDigitada(baseDigitar.PrecoInformado , novo, Convert.ToDecimal(baseDigitar.QuantidadeDestinadaCliente), index  );
               
                QtdDigitacao = Qtd + QtdDigitacao;

                for (int i = 0; i < ListNegocio.Count; i++)
                {
                    if (ListNegocio[i].Preco == baseDigitar.PrecoInformado)
                        if (QtdDigitacao <= ListNegocio[i].Quantidade)
                            return true;
                        else
                        {
                            return false;
                        }
                }
                return false;
            }


            public bool ValidaQtdTotalDigitada(bool novo,decimal  qtdeDigitada , Model.BaseDigitacao regAtual , Int32 index)
            {
                if (ListDigitacao.Count == 0)
                    return true;
                decimal? QtdDigitacao = 0;
                bool encontrado = false;
                if (novo)
                {
                     
                    QtdDigitacao = ListDigitacao.Where(y=>y.State!= State.Deleted).Sum(x => x.QuantidadeDestinadaCliente);
                    QtdDigitacao += qtdeDigitada;
                }
                else
                {

                      
                    for  (int i=0 ; i<ListDigitacao.Count; i++ )
                    {

                        if (ListDigitacao[i].State != State.Deleted)
                        {
                           if (i==index )
                            {
                                    QtdDigitacao += qtdeDigitada;

                            }
                            else
                                QtdDigitacao += ListDigitacao[i].QuantidadeDestinadaCliente;

                        }
                    }
                }
              //  if (!encontrado && !novo)
               //     QtdDigitacao += regAtual.QuantidadeDestinadaCliente;

                decimal? QtdNegocio = ListNegocio.Sum(y => y.Quantidade );

                return (QtdDigitacao <= QtdNegocio); 

            }
            public bool ValidaQtdTotal(decimal? Qtd, decimal? QtdAnteiror,  bool novo, int index)
            {
                decimal? QtdDigitacao = 0;
                decimal? QtdTotal = 0;

                QtdDigitacao = ObterQuantidadeDigitada(QtdAnteiror,Qtd, index );
                
                if (QtdAnteiror == null || QtdDigitacao ==0 ) 
                    QtdDigitacao = Qtd + QtdDigitacao;

                for (int i = 0; i < ListNegocio.Count; i++)
                {
                    QtdTotal = ListNegocio[i].Quantidade + QtdTotal;
                }
                if (QtdTotal < QtdDigitacao)
                    return false;
                else
                    return true;
            }

            public bool ValidaPercentual(decimal? PercentualNovo, decimal? PercentualAntigo, Int32 index  )
            {
                decimal? PercentualTotal = 0;
                for (int i = 0; i < ListDigitacao.Count; i++)
                {

                    if (ListDigitacao[i].State != State.Deleted)
                    {
                        if (PercentualAntigo == null || PercentualAntigo == 0)
                            PercentualTotal = ListDigitacao[i].PercentualDistribuido + PercentualTotal;

                        else
                        {
                            if (i==index )
                            {
                                    PercentualTotal = PercentualNovo + PercentualTotal;
                            }
                            else

                                PercentualTotal += ListDigitacao[i].PercentualDistribuido ;
                        }

                    }
                }
                if (PercentualAntigo == null || PercentualAntigo == 0 ) 

                    return ((PercentualTotal + PercentualNovo) <= 100); 
                else
                     return (PercentualTotal  <= 100);

            }

            /// <summary>
            /// Preenche informações de carteira.
            /// Não preenche Apelido e dígito do cliente.
            /// </summary>
            public void ConsultarMenorCarteria()
            {
                if (pLoteOrdem.Count == 1)
                {
                    if (tipoOrdemDistribuicao != Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdemDistribuicao.POP)
                    {
                        try
                        {
                            Communication.Carteira objCarteira = new Communication.Carteira(this.Session);
                            Model.Parameter.ConsultarMenorCarteiraRequest ConsultarMenorCarteiraRequest = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarMenorCarteiraRequest();
                            ConsultarMenorCarteiraRequest.CodigoBolsa = ListOrdem[0].Bolsa;
                            ConsultarMenorCarteiraRequest.CodigoMercado = (Model.Enum.TipoMercado?)ListOrdem[0].TipoMercado;
                            ConsultarMenorCarteiraRequest.NaturezaOperacao = (Model.Enum.TipoNaturezaOperacao?)ListOrdem[0].NaturezaOperacao;
                            this._carteiraMercado = objCarteira.ConsultarMenorCarteira(ConsultarMenorCarteiraRequest);
                        }
                        catch (Exception ex)
                        {

                            base.HandleException(ex);

                        }
                    }

                    else
                    {
                        this._carteiraMercado = new Sinacor.UI.Bovespa.Ordens.Model.CarteiraMercado(); 
                        this._carteiraMercado.CodigoCarteira = 277; 
                      
                    }
                }

            }

            public bool ValidarCarteira(int Carteira)
            {
                try
                {
                    Communication.Carteira objCarteira = new Sinacor.UI.Bovespa.Ordens.Communication.Carteira(this.Session);
                    Model.Parameter.ValidarCarteiraMercadoRequest validarCarteiraMercadoReq = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ValidarCarteiraMercadoRequest();
                    validarCarteiraMercadoReq.CodigoBolsa = pLoteOrdem[0].Bolsa;
                    validarCarteiraMercadoReq.CodigoMercado = (Model.Enum.TipoMercado?)pLoteOrdem[0].TipoMercado;
                    validarCarteiraMercadoReq.NaturezaOperacao = (Model.Enum.TipoNaturezaOperacao?)pLoteOrdem[0].NaturezaOperacao;
                    validarCarteiraMercadoReq.CodigoCarteira = Carteira;
                    return objCarteira.ValidarCarteiraMercado(validarCarteiraMercadoReq);
                }
                catch (Exception ex)
                {
                    base.HandleException(ex);
                    return false; 
                }
            }

            public void ConsultarClienteCVM(string CodigoCVM)
            {
                if (CodigoCVM != null)
                {
                    try
                    {
                        Model.Parameter.ConsultarClienteRequest pConsultarCliente = new Model.Parameter.ConsultarClienteRequest();
                        pConsultarCliente.CodigoOperacionalCVM = CodigoCVM;
                        Communication.Cliente objCliente = new Communication.Cliente(this.Session);
                        this.ListModelClienteCVM = objCliente.ConsultarCliente(pConsultarCliente);
                        if (this.ListModelClienteCVM.Count > 1)
                            _view.ApresentarPopupCliente();
                        else
                        {
                            blConsultaCVM = false;
                            ConsultarClienteCodigo(ListModelClienteCVM[0].Codigo);
                            _view.ApresentarCliente();

                        }
                    }
                    catch (Exception ex)
                    {

                        Sinacor.Infra.Common.Validation.ValidationError retorno = new Sinacor.Infra.Common.Validation.ValidationError();
                        retorno.ErrorMessage = ((BusinessException)(ex)).Message;
                        retorno.ErrorNumber = ((BusinessException)(ex)).ErrorNumber;
                        retorno.ResourceKey = ((BusinessException)(ex)).ResourceKey;
                        _view.ErroNaPesquisaCliente(retorno);
                    }
                }
            }

            public void ConsultarClienteApelido(string pApelido, bool carregar)
            {
                if (pApelido != null)
                {
                    try
                    {
                        Model.Parameter.ConsultarClienteRequest pConsultarCliente = new Model.Parameter.ConsultarClienteRequest();
                        pConsultarCliente.Apelido = pApelido;
                        pConsultarCliente.Origem = "ERRO_CLIENTE_INEXISTENTE_OU_USUARAIOSEMACESSO"; 
                        Communication.Cliente objCliente = new Communication.Cliente(this.Session);

                        ///Ref. ao BUG 21225
                        ///Devido a existência de um LIKE na consulta de cliente, e para não carregar um cliente
                        ///diferente do filtro passado, foi realizada essa validação após a consulta.
                        Model.Cliente _clienteConsultado = objCliente.ConsultarCliente(pConsultarCliente)[0];
                        if (_clienteConsultado != null &&
                            pApelido.Trim() == _clienteConsultado.Apelido.Trim())
                        {
                            this.ModelClienteDigitacao = _clienteConsultado;

                            if (carregar)
                            {
                                _view.ApresentarCliente();
                                _view.ApresentarDigitoCliente();
                            }
                        }
                        else
                        {
                            this.ModelClienteDigitacao = null;
                        }
                    }
                    catch (Exception ex)
                    {

                      
                        Sinacor.Infra.Common.Validation.ValidationError retorno = new Sinacor.Infra.Common.Validation.ValidationError();
                        retorno.ErrorMessage = ((BusinessException)(ex)).Message;
                        retorno.ErrorNumber = ((BusinessException)(ex)).ErrorNumber;
                        retorno.ResourceKey = ((BusinessException)(ex)).ResourceKey;
                        _view.ErroNaPesquisaCliente(retorno);
                    }
                }
            }

            private Int32  ConsultarCodgioClienteApelido(string pApelido)
            {

                Int32 codigoRetorno = 0; 
                if (pApelido != null)
                {
                    try
                    {
                        Model.Parameter.ConsultarClienteRequest pConsultarCliente = new Model.Parameter.ConsultarClienteRequest();
                        pConsultarCliente.Apelido = pApelido;
                        Communication.Cliente objCliente = new Communication.Cliente(this.Session);
                        codigoRetorno = (Int32)  (objCliente.ConsultarCliente(pConsultarCliente)[0]).Codigo;

                    }
                    catch (Exception ex)
                    {

                        base.HandleException(ex);
                    
                    }
                }
                return codigoRetorno; 
            }

            public void ConsultarClienteApelidoAlteracao(string pApelido)
            {
                try
                {
                    if (!string.IsNullOrEmpty(pApelido))
                    {
                        Model.Parameter.ConsultarClienteRequest pConsultarCliente = new Model.Parameter.ConsultarClienteRequest();
                        pConsultarCliente.Apelido = pApelido;
                        Communication.Cliente objCliente = new Communication.Cliente(this.Session);
                        this.ModelClienteDigitacao = objCliente.ConsultarCliente(pConsultarCliente)[0];
                    }
                }
                catch (Exception ex)
                {

                    Sinacor.Infra.Common.Validation.ValidationError retorno = new Sinacor.Infra.Common.Validation.ValidationError();
                    retorno.ErrorMessage = ((ValidationException)(ex)).Message;
                    _view.ErroNaPesquisaCliente(retorno);
                }
            }

            public void ConsultarClienteCodigo(int? pCodigo)
            {
                try
                {

                    Model.Parameter.ConsultarClienteRequest pConsultarCliente = new Model.Parameter.ConsultarClienteRequest();
                    pConsultarCliente.Codigo = pCodigo;
                    Communication.Cliente objCliente = new Communication.Cliente(this.Session);
                    this.ModelClienteDigitacao = objCliente.ConsultarCliente(pConsultarCliente)[0];
                    _view.ApresentarCliente();
                    _view.ApresentarDigitoCliente(); 

                }
                catch (Exception ex)
                {

                    Sinacor.Infra.Common.Validation.ValidationError retorno = new Sinacor.Infra.Common.Validation.ValidationError();
                    retorno.ErrorMessage = ((BusinessException)(ex)).Message;
                    retorno.ErrorNumber = ((BusinessException)(ex)).ErrorNumber;
                    retorno.ResourceKey = ((BusinessException)(ex)).ResourceKey;

                    _view.ErroNaPesquisaCliente(retorno);
                }
            }

            public void ValidarCliente(Boolean bMostrarErro)
            {
               try
                {
                    _bErro = false;
                    retorno = null;
                    if (ModelClienteDigitacao != null )
                    {
                        if (ModelClienteDigitacao.Codigo != null)
                        {
                            if ((int)ModelClienteOrdem.Codigo != (int)ModelClienteDigitacao.Codigo ||  tipoOrdemDistribuicao == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdemDistribuicao.AdministradoConcorrente)
                            {
                                Model.Parameter.ValidarClienteRequest pValidarCliente = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ValidarClienteRequest();
                                pValidarCliente.CodigoCliente = (int)ModelClienteDigitacao.Codigo;
                                pValidarCliente.CodigoClienteOrdem = (int)ModelClienteOrdem.Codigo;
                                if (blDiscricionarios == true)
                                    pValidarCliente.TipoOrdem = Model.Enum.TipoOrdem.Discricionaria;
                                //if (pLoteOrdem.Count == 1)
                                //    pValidarCliente.TipoOrdemDistribuicao = (Model.Enum.TipoOrdemDistribuicao)pLoteOrdem[0].TipoOrdemDistribuicao;
                                //else

                               pValidarCliente.TipoOrdemDistribuicao = tipoOrdemDistribuicao ;

                                if (ModelClienteDigitacao.ClienteContaDeposito  != null)

                                    pValidarCliente.CodigoClienteOrdemAtual = (Int32)ModelClienteDigitacao.ClienteContaDeposito; 

                                else
                                    pValidarCliente.CodigoClienteOrdemAtual = (Int32)ModelClienteDigitacao.ClienteContaInvestimento;

                                if (pValidarCliente.CodigoClienteOrdemAtual == 0)
                                    pValidarCliente.CodigoClienteOrdemAtual = (int) ModelClienteDigitacao.Codigo;  

                                Communication.Cliente objCliente = new Communication.Cliente(this.Session);
                                retorno = objCliente.ValidarCliente(pValidarCliente);
                                if (retorno.IsValid == false)
                                {
                                    bErro = true;
                                    if (bMostrarErro == false)
                                        this.View.InformarErroCodigoCliente(retorno.Error);
                                    else
                                        this.View.MostrarMensagemErroValidacaoCliente(retorno.Error);
                                }
                                else
                                {

                                    this.ConsultarUsuarioClienteInstitucional();
                                    this.VerificarDigitacaoCliente();
                                    this.VerificarPreenchimentoAutomaticoGrid();
                                    this.View.MostrarPercentualAcrescimo();
                                }
                            }

                            else
                            {
                                    this.ConsultarUsuarioClienteInstitucional();
                                    this.VerificarDigitacaoCliente();
                                    this.VerificarPreenchimentoAutomaticoGrid();
                                    this.View.MostrarPercentualAcrescimo();


                            }

                        }
                    }
                }
                catch (Exception ex)
                {
                    base.HandleException(ex);
                }

            }

            public void ValidarDigitoVerifClienteInstitucional( int? CodigoClienteCustodia,int? CodigoUsuarioInstitucional, int?  DigitoVerifUsuarioInstitucional ) 
            {
                 try
                {


                    Model.Parameter.ValidarDigitoVerifClienteInstitucionalRequest VerifClienteInst = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ValidarDigitoVerifClienteInstitucionalRequest();
                     VerifClienteInst.CodigoClienteInstitucional = CodigoClienteCustodia;
                     VerifClienteInst.CodigoUsuarioInstitucional = CodigoUsuarioInstitucional;
                     VerifClienteInst
                         .DigitoVerifUsuarioInstitucional = DigitoVerifUsuarioInstitucional;
                     Communication.Cliente objCliente = new Communication.Cliente(this.Session);
                     
                     ValidationResult retorno = objCliente.ValidarDigitoVerifClienteInstitucional(VerifClienteInst);
                     if (retorno.IsValid == false)
                    {
                        this.View.InformarErroDigVerifClienteInst(retorno.Error);
                    }
                }


                catch (Exception ex)
                {
                    base.HandleException(ex);
                }

            }

            private void VerificarDigitacaoCliente()
            {
                
                if (this.ModelAgenteCustodia.DigitoClienteCustodiante != null ||
                                         this.ModelUsuarioInstitucional.CodigoClienteInstitucional != null) 
                {
                    //&& (
                   //                      this.NaoDerivativo == true)
                    this.VerificaDigitacaoDigitoCliente = false;
                    //this._view.ApresentarDigitoCliente();
                }
                else
                { this.VerificaDigitacaoDigitoCliente = true; }


            }

            private void VerificarPreenchimentoAutomaticoGrid()
            {
                if ((this.ModelAgenteCustodia.DigitoClienteCustodiante != null ||
                       this.ModelUsuarioInstitucional.CodigoClienteInstitucional != null) && this.Derivativo == false && this.blInserir == false)
                {
                    this._view.ApresentarTipoLiquidacaoDadosUsuario(true);
                }
                else
                {
                    if (this.ModelAgenteCustodia.DigitoClienteCustodiante == null && this.ModelUsuarioInstitucional.CodigoClienteInstitucional == null  )
                    {
                    this._view.ApresentarTipoLiquidacaoNormal(); 
                    }
                }

            }

            public void ConsultarUsuarioClienteInstitucional()
            {
                try
                {
                    if (ModelClienteDigitacao != null)
                    {
                        if (ModelClienteDigitacao.Codigo != null)
                        {
                            Communication.Cliente objCliente = new Communication.Cliente(this.Session);
                            Model.Parameter.ConsultarClientePorCodigoRequest pConsultarCliente = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarClientePorCodigoRequest();
                            pConsultarCliente.CodigoCliente = (int)ModelClienteDigitacao.Codigo;
                            this.ModelAgenteCustodia = objCliente.ConsultarAgenteCustodia(pConsultarCliente);
                            this.ModelUsuarioInstitucional = objCliente.ConsultarUsuarioInstitucional(pConsultarCliente);
                            
                        }
                    }
                }
                catch (Exception ex)
                {

                    base.HandleException(ex);

                }
            }

            public void AtualizarQuantidadeEspefificar()
            {

                // Todo: If adicionado por causa  dos testes depois devera ser removido

               // if (!this.blPercentual)
                {
                    //decimal? QTD;
                    //decimal? QTDAnte = 0;
                    if (ListDigitacao.Count == 0)
                    {
                        for (int Index = 0; Index < ListNegocio.Count; Index++)
                        {
                            ListNegocio[Index].QuantidadeCasada = ListNegocio[Index].Quantidade;
                        }

                    }
                    else
                    {

                        if (_blPrecoMedio == false)
                        {

                            for (int Index = 0; Index < ListNegocio.Count; Index++)
                            {
                                if (_blPercentual == true)
                                    ListNegocio[Index].QuantidadeCasada = ListNegocio[Index].Quantidade - (ListNegocio[Index].Quantidade * (PercentualDigitado / 100));

                                else
                                    ListNegocio[Index].QuantidadeCasada = ListNegocio[Index].Quantidade - ObterQuantidadeDigitada(ListNegocio[Index].Preco);
                            }
                        }
                        else
                        {
                            for (int Index = 0; Index < ListNegocio.Count; Index++)
                            {
                                ListNegocio[Index].QuantidadeCasada = ListNegocio[Index].Quantidade;

                                //}
                            }
                        }
                    }
                }
            }

            private decimal? ObterQuantidadeDigitada(decimal? Preco)
            {
                decimal? QtdDigitacao = 0;

                for (int i = 0; i < ListDigitacao.Count; i++)
                {
                    if (ListDigitacao[i].State != State.Deleted )
                    {
                        if (ListDigitacao[i].PrecoInformado == Preco)
                            QtdDigitacao = ListDigitacao[i].QuantidadeDestinadaCliente + QtdDigitacao;
                    }

                }
                return QtdDigitacao;
            }

            public void VerificarDigitacao()
            {
                if (ListDigitacao.Count == 0)
                    _view.ConfiguraDigitacaoVazia();
            }

            public void VerificaDiscricionario()
            {
                blDiscricionarios = (pLoteOrdem[0].Discricionaria == "S");
            }

            public void ConsultarClienteADR()
            {
                try
                {
                    Model.Parameter.ConsultarADRRequest ReqAdrRequest = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarADRRequest();
                    Communication.Negocio objNegocio = new Communication.Negocio(this.Session);
                    ReqAdrRequest.CodigoNegocio = ( ListOrdem[0].CodigoNegocio  == null )  ? ListOrdem[0].Titulo :ListOrdem[0].CodigoNegocio;
                    this.ModelClienteADR = objNegocio.ConsultarClienteADR(ReqAdrRequest);
                    View.ApresetarClienteADR();
                }
                catch (Exception ex)
                {

                    base.HandleException(ex);

                }
            }
            public void ConsultarPosicaoCustodia ()
            {
                try
                {
                    var ativo = from Bovespa.Ordens.Model.Ordem lista in ListOrdem  where lista.NaturezaOperacao== Model.Enum.TipoNaturezaOperacao.Venda 
                                                                                    group lista by  new {lista.Titulo} into titulo
                                                                                    select new {retorno = titulo}  
                                                                                        ;

                    if (  ativo.Count()> 0  )
                    {

                    ModelCollection<Model.BaseDigitacao> listInsert = ListDigitacao;
                    int max = listInsert.Count;
                    Model.Parameter.ConsultarPosicaoCustodiaRequest ReqCustodia = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarPosicaoCustodiaRequest();
                    for (int i = 0; i < max; i++)
                    {

                        if (ReqCustodia.Apelido != listInsert[i].ApelidoCliente && listInsert[i].State !=State.Deleted)
                        {
                            ReqCustodia = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarPosicaoCustodiaRequest();
                            ReqCustodia.Apelido = listInsert[i].ApelidoCliente;
                            
                            foreach ( var item in ativo)
                            {
                                ReqCustodia.Ativos.Add(item.retorno.Key.Titulo); 
                            }
                            ReqCustodia.Carteira = listInsert[i].CodigoCarteira; 
                            Communication.Custodia objCustodia = new Communication.Custodia(this.Session);
                            ModelPosicaoCustodia = objCustodia.ConsultarPosicaoCustodia(ReqCustodia);
                            this.View.ExibirMensagemSaldoCliente(this.MontarMensagem(listInsert[i].ApelidoCliente, ReqCustodia));
                        }
                    }
                    
                    
                  
                   
                    
                    } 

                }
                catch (Exception ex)
                {
                    base.HandleException(ex);
                
                }

           
            
            }
            public string MontarMensagem(string pApelido, Model.Parameter.ConsultarPosicaoCustodiaRequest pTitulo)
            {
                StringBuilder strMensagem = new StringBuilder();

                if (ModelPosicaoCustodia.Custodias.Count > 0)
                {
                    strMensagem.Append(((string)PSE.Framework.UI.Resources.ResourceProviderManager.GetResourceProvider().TryGetResource("Bovespa.Ordens.Message.EnviarAvisoParte1")).Replace("{cliente}", pApelido));
                    strMensagem.Append(" ");
                    foreach (Model.Custodia custodias in ModelPosicaoCustodia.Custodias)
                    {
                        strMensagem.Append(((string)PSE.Framework.UI.Resources.ResourceProviderManager.GetResourceProvider().TryGetResource("Bovespa.Ordens.Message.EnviarAvisoParte2")));
                        strMensagem.Replace("{titulo}", custodias.Titulo);
                        strMensagem.Replace("{carteira}", custodias.Carteira.ToString());
                        strMensagem.Replace("{negociavel}", custodias.Negociavel.ToString());
                        strMensagem.Replace("{disponivel}", custodias.Disponivel.ToString());
                        strMensagem.Append(" ");

                    }

                }

                else
                {
                    strMensagem.Append(((string)PSE.Framework.UI.Resources.ResourceProviderManager.GetResourceProvider().TryGetResource("Bovespa.Ordens.Message.EnviarAvisoParte1")).Replace("{cliente}", pApelido));
                    strMensagem.Append(" ");
                    bool controle = false;
                    foreach (string pitem in pTitulo.Ativos)
                    {
                        if (!controle)
                        {
                            strMensagem.Append(((string)PSE.Framework.UI.Resources.ResourceProviderManager.GetResourceProvider().TryGetResource("Bovespa.Cliente.Message.MensagemCustodiaAviso")).Replace("{titulo}", pitem.ToString()));
                            controle = true;

                        } 
                        else

                            strMensagem.Append(((string)PSE.Framework.UI.Resources.ResourceProviderManager.GetResourceProvider().TryGetResource("Bovespa.Cliente.Message.MensagemCustodiaAviso")).Replace(".", "") + ";" + pitem.ToString());

                    }
                }
                if (ModelPosicaoCustodia.Custodias.Count == 0)
                {
                    strMensagem.Replace(";", ".", strMensagem.Length - 1, 1); 
                }
                return strMensagem.ToString(); 
                
            
            }
            
            
        #endregion 

        #region Private

        private void ZeraValores()
        {

            this.QuantidadeDigitadaAnexoIV = 0;
            this.QuantidadeDigitadaAnexoV = 0;
            this.QuantidadeDigitada = 0;
            this.QuantidadeCasada = 0;
            this.QuantidadeCasadaAnexoIV = 0;
            this.QuantidadeCasadaAnexoV = 0;
            this.PercentualCasado = 0;
            this.PercentualDigitado = 0;
            this.Saldo = 0;
            this.SaldoAnexoIV = 0;
            this.SaldoAnexoV = 0;
            this.SaldoPercentual = 0;
            if (blDireto)
            {
                for (int Index = 0; Index < ListNegocio.Count; Index++)
                {
                    ListNegocio[Index].QuantidadeCasada = 0;
                }
            }
        }

        private void AtualizarQuantidadeInformada()
        {
                            // Todo: If adicionado por causa  dos testes depois devera ser removido

            //if (!this.blPercentual)
            {
                int Count = ListDigitacao.Count;
                Decimal? PercentualAnexo4;
                Decimal? PercentualAnexo5;
                PercentualAnexo4 = 0;
                PercentualAnexo5 = 0;

                for (int i = 0; i < Count; i++)
                {
                    if (ListDigitacao[i].State != State.Deleted)
                    {
                        if (!blPercentual)
                        {

                            if (ListDigitacao[i].TipoLiquidacao == Model.Enum.TipoLiquidacaoDistribuicao.AnexoIV)
                                this.QuantidadeDigitadaAnexoIV = ListDigitacao[i].QuantidadeDestinadaCliente + QuantidadeDigitadaAnexoIV;
                            else if (ListDigitacao[i].TipoLiquidacao == Model.Enum.TipoLiquidacaoDistribuicao.AnexoV)
                                this.QuantidadeDigitadaAnexoV = ListDigitacao[i].QuantidadeDestinadaCliente + QuantidadeDigitadaAnexoV;
                            this.QuantidadeDigitada = ListDigitacao[i].QuantidadeDestinadaCliente + QuantidadeDigitada;

                        }
                        else
                        {
                            if (ListDigitacao[i].TipoLiquidacao == Model.Enum.TipoLiquidacaoDistribuicao.AnexoIV)
                                PercentualAnexo4 = ListDigitacao[i].PercentualDistribuido + PercentualAnexo4;
                            else if (ListDigitacao[i].TipoLiquidacao == Model.Enum.TipoLiquidacaoDistribuicao.AnexoV)
                                PercentualAnexo5 = ListDigitacao[i].PercentualDistribuido + PercentualAnexo5;

                            this.PercentualDigitado = ListDigitacao[i].PercentualDistribuido + this.PercentualDigitado;

                        }

                    }
                }

                // Valores para percentual 
                if (blPercentual)
                {
                   // this.QuantidadePercentualDigitada = this.QuantidadeCasadaPercentual * (this.PercentualDigitado / 100);
                    this.QuantidadeDigitadaAnexoIV = this.QuantidadeCasadaAnexoIV * (PercentualAnexo4 / 100);
                    this.QuantidadeDigitadaAnexoV = this.QuantidadeCasadaAnexoV * (PercentualAnexo5 / 100);
                }
            }
        }

        public void AtualizarQtdCasada()
        {

            //if (!this.blPercentual)
            {
                this.QuantidadeCasada = 0;
                this.PercentualCasado = 0;
               // if (ListDigitacao.Count > 0)
                {
                    for (int i = 0; i < ListOrdem.Count; i++)
                    {
                        if (this.ListOrdem[i].Quantidade != null )
                            this.QuantidadeCasada = this.ListOrdem[i].QuantidadeCasada + QuantidadeCasada;


                        if (this.ListOrdem[i].Quantidade != null )
                            this.QuantidadeCasadaPercentual = this.ListOrdem[i].QuantidadeCasada + QuantidadeCasada;

                        if (this.ListOrdem[i].QuantidadeAnexo4 != null )
                            this.QuantidadeCasadaAnexoIV = ListOrdem[i].QuantidadeAnexo4 + QuantidadeCasadaAnexoIV;
                        if (this.ListOrdem[i].QuantidadeAnexo5 != null)
                            this.QuantidadeCasadaAnexoV = ListOrdem[i].QuantidadeAnexo5 + QuantidadeCasadaAnexoV;
                    }

                   // if (blPercentual)
                        this.PercentualCasado = 100;


                }
            }
        }

        private void AtualizarPercentual()
        {
                            // Todo: If adicionado por causa  dos testes depois devera ser removido

            if (this.blPercentual)
            {
                if (this.QuantidadeDigitada > 0)
                    this.PercentualDigitado = (decimal?)decimal.Round(Convert.ToDecimal(((this.QuantidadeDigitada * 100) / this.QuantidadeCasadaPercentual)), 4);
            }
        }

        private void AtualizarSaldo()
        {
            if (this.QuantidadeDigitada > 0 || this.QuantidadeCasada> 0) 
            this.Saldo = this.QuantidadeCasada - this.QuantidadeDigitada;
            this.SaldoAnexoIV = this.QuantidadeCasadaAnexoIV - this.QuantidadeDigitadaAnexoIV;
            this.SaldoAnexoV = this.QuantidadeCasadaAnexoV - this.QuantidadeDigitadaAnexoV;
            this.SaldoPercentual = this.PercentualCasado - this.PercentualDigitado;
        }

        private decimal? ObterQuantidadeDigitada(decimal? Preco, bool novo,  decimal qtde, int index  )
        {
            decimal? QtdDigitacao = 0;
            Int16 controle = 0; 

            for (int i = 0; i < ListDigitacao.Count; i++)
            {
                if (ListDigitacao[i].State != State.Deleted  )
                {
                    if (novo)
                    {
                        if (ListDigitacao[i].PrecoInformado == Preco)
                            QtdDigitacao = ListDigitacao[i].QuantidadeDestinadaCliente + QtdDigitacao;
                    }
                    else
                    {
                        if (i != index)
                        {
                            if (ListDigitacao[i].PrecoInformado == Preco)
                                QtdDigitacao += ListDigitacao[i].QuantidadeDestinadaCliente;
                        }
                    }


                }

                //else
                //    if (ListDigitacao[i].PrecoInformado == Preco && i == index && !novo )
                //        QtdDigitacao = QtdDigitacao;

            }
            return QtdDigitacao;
        }

        private bool precoDiretoQuantidadeSuperior()
        {
            bool retorno = false;


            foreach (Negocio neg in ListNegocio)
            {
                
                decimal qtdeTotal = Convert.ToDecimal( 
                                    ListDigitacao.Where (p => p.State != State.Deleted && p.PrecoInformado == neg.Preco).Sum(m =>m.QuantidadeDestinadaCliente)
                                    );

                if (qtdeTotal > neg.Quantidade)
                {
                    retorno = true;
                    break;  
                }
            }


            return retorno; 
        }
        private decimal? ObterQuantidadeDigitada(decimal? qtAnterior, decimal? qtNova , int index  )
        {
            decimal? QtdDigitacao = 0;
 
            for (int i = 0; i < ListDigitacao.Count; i++)
            {
                if (qtAnterior == null)
                {
                    if (ListDigitacao[i].State != State.Deleted)
                        QtdDigitacao = ListDigitacao[i].QuantidadeDestinadaCliente + QtdDigitacao;
                }

                else
                {
                    if (ListDigitacao[i].State != State.Deleted)
                    {
                        if (i==index )
                        {
           
                            QtdDigitacao = qtNova + QtdDigitacao;

                        }
                        else
                            QtdDigitacao = ListDigitacao[i].QuantidadeDestinadaCliente + QtdDigitacao;
                    }
 
                }


            }
            return QtdDigitacao;
        }

        private List<Model.Enum.TipoOrdem> TranslatorEnumWrapperTipoOrdemtoEnum(List<EnumWrapper<Model.Enum.TipoOrdem>> pFrom)
        {
            List<Model.Enum.TipoOrdem> pto = new List<Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdem>();
            foreach (EnumWrapper<Model.Enum.TipoOrdem> pfrom in pFrom)
            {
                pto.Add((Model.Enum.TipoOrdem)pfrom);
            }
            return pto;
        }

        #endregion

        #endregion


        public bool validarPercentualTotalDigitado(decimal? percentualOriginal, decimal? percentualNovo)
        {
           


            decimal? PercentualTotal = 0;
            if (percentualOriginal == null)
            {
                for (int i = 0; i < ListDigitacao.Count; i++)
                {

                    if (ListDigitacao[i].State != State.Deleted)
                    {
                        PercentualTotal = ListDigitacao[i].PercentualDistribuido + PercentualTotal;
                    }
                }
            }

            else
            {
                bool procurar = false; 
                for (int i = 0; i < ListDigitacao.Count; i++)
                {

                    if (ListDigitacao[i].State != State.Deleted)
                    {
                        if (!procurar)
                        {
                            if (ListDigitacao[i].PercentualDistribuido == percentualOriginal)
                            {
                                PercentualTotal = percentualNovo  + PercentualTotal;
                            }
                            else
                                PercentualTotal = ListDigitacao[i].PercentualDistribuido + PercentualTotal;
                        }
                        else

                            PercentualTotal = ListDigitacao[i].PercentualDistribuido + PercentualTotal;
                    }
                }
 
            }
            return (PercentualTotal == 100); 

        }


        public bool validarQuantidadeTotalDigitado()
        {


            if (!verificarListaTipoAnexo())
                // Validação para fechar a tela  caso não exista no grid anexo 4 ou anexo 5
                return (QuantidadeCasada == QuantidadeDigitada && QuantidadeDigitada>0);

            else

                // Validação para fechar a tela  caso exista no grid anexo 4 ou anexo 5
                return (QuantidadeCasada == QuantidadeDigitada && QuantidadeDigitada > 0) ||
                        (QuantidadeCasadaAnexoIV == QuantidadeDigitadaAnexoIV && QuantidadeDigitadaAnexoIV>0 &&
                        QuantidadeCasadaAnexoV==QuantidadeDigitadaAnexoV && QuantidadeDigitadaAnexoV >0  );

         }


        private bool verificarListaTipoAnexo()
        {


            var anexo = from Model.BaseDigitacao lista in ListDigitacao
                        where (lista.TipoLiquidacao == Model.Enum.TipoLiquidacaoDistribuicao.AnexoIV 
                        ||lista.TipoLiquidacao == Model.Enum.TipoLiquidacaoDistribuicao.AnexoV)  && lista.State != State.Deleted 
                        select new { retorno = lista.TipoLiquidacao } ;

            return (anexo.Count() > 0);


        }


        public  void ValidarSaldoMensagem(Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoDistribuicao tipoValidacao)
        {
            this.bErro = false; 
            if (tipoValidacao == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoDistribuicao.Percentual)
            {
                if (this.SaldoPercentual < 0)
                {
                    bErro = true;
                    retorno = new ValidationResult(new ValidationError(5451,
                                                    ((string)PSE.Framework.UI.Resources.ResourceProviderManager.GetResourceProvider().TryGetResource
                                                    ("Bovespa.Ordens.Message.ErroTotalPorcentagem1")), "Bovespa.Ordens.Message.ErroTotalPorcentagem1"));

                    bErro = true; 
                }                  
            }

            if (tipoValidacao == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoDistribuicao.PrecoMedio || 
                tipoValidacao == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoDistribuicao.PrecoMedioPorVolume)
            {
                if (this.Saldo < 0)
                {
                    bErro = true;
                    retorno = new ValidationResult(new ValidationError(5457,
                                                    ((string)PSE.Framework.UI.Resources.ResourceProviderManager.GetResourceProvider().TryGetResource
                                                    ("Bovespa.Ordens.Message.ErroTotalDigitacao")), "Bovespa.Ordens.Message.ErroTotalDigitacao"));

                    bErro =true; 
                }

            }

            if (tipoValidacao == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoDistribuicao.Direto)
            {

                if (precoDiretoQuantidadeSuperior())
                {
                    bErro = true;
                    retorno = new ValidationResult(new ValidationError(6912,
                                                    ((string)PSE.Framework.UI.Resources.ResourceProviderManager.GetResourceProvider().TryGetResource
                                                    ("Bovespa.Ordens.Message.ErroPrecoInformadoQuantidade")), "Bovespa.Ordens.Message.ErroPrecoInformadoQuantidade"));
                }
                else
                {
                    if (this.Saldo < 0)
                    {
                        bErro = true;
                        retorno = new ValidationResult(new ValidationError(5457,
                                                        ((string)PSE.Framework.UI.Resources.ResourceProviderManager.GetResourceProvider().TryGetResource
                                                        ("Bovespa.Ordens.Message.ErroTotalDigitacao")), "Bovespa.Ordens.Message.ErroTotalDigitacao"));
                    }
                }

            }

            if (bErro)
            {
                BusinessException ex = new BusinessException(retorno.Error.ErrorNumber);
                ex.ResourceKey = retorno.Error.ResourceKey;
                base.HandleException(ex); 
            }
        }
    }
}
